package com.tennis.tennisreservation.controller;

import com.tennis.tennisreservation.common.Result;
import com.tennis.tennisreservation.entity.Coupon;
import com.tennis.tennisreservation.service.CouponService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;

/**
 * 红包控制器
 * 处理红包相关的请求
 */
@RestController
@RequestMapping("/api/coupon")
public class CouponController {

    private static final Logger logger = LoggerFactory.getLogger(CouponController.class);

    @Autowired
    private CouponService couponService;

    /**
     * 创建单个红包
     * @param coupon 红包信息
     * @return 创建结果
     */
    @PostMapping("/create")
    public Result<?> createCoupon(@RequestBody Coupon coupon) {
        try {
            logger.info("创建红包，有效期: 从 {} 到 {}", coupon.getValidFrom(), coupon.getValidTo());
            
            // 处理结束时间，确保结束时间为当天的23:59:59
            if (coupon.getValidTo() != null) {
                LocalDateTime validTo = coupon.getValidTo();
                LocalDateTime adjustedValidTo = LocalDateTime.of(
                    validTo.toLocalDate(), 
                    LocalTime.of(23, 59, 59)
                );
                coupon.setValidTo(adjustedValidTo);
                logger.info("调整后的结束时间: {}", adjustedValidTo);
            }
            
            Coupon created = couponService.createCoupon(coupon);
            return Result.success(created);
        } catch (Exception e) {
            logger.error("创建红包失败", e);
            return Result.fail("创建红包失败：" + e.getMessage());
        }
    }
    
    /**
     * 批量创建红包
     * @param userId 用户ID
     * @param amount 红包金额
     * @param validDays 有效天数
     * @param count 创建数量
     * @return 创建结果
     */
    @PostMapping("/batch")
    public Result<?> createCouponBatch(
            @RequestParam Long userId,
            @RequestParam BigDecimal amount,
            @RequestParam(defaultValue = "30") Integer validDays,
            @RequestParam(defaultValue = "1") Integer count) {
        try {
            List<Coupon> coupons = couponService.createCouponBatch(userId, amount, validDays, count);
            return Result.success(coupons);
        } catch (Exception e) {
            return Result.fail("批量创建红包失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取红包详情
     * @param id 红包ID
     * @return 红包详情
     */
    @GetMapping("/{id}")
    public Result<Coupon> getCouponById(@PathVariable Long id) {
        Coupon coupon = couponService.getCouponById(id);
        
        if (coupon != null) {
            return Result.success(coupon);
        } else {
            return Result.fail("红包不存在");
        }
    }
    
    /**
     * 获取用户的红包列表
     * @param userId 用户ID
     * @return 红包列表
     */
    @GetMapping("/user/{userId}")
    public Result<List<Coupon>> getCouponsByUserId(@PathVariable Long userId) {
        List<Coupon> coupons = couponService.getCouponsByUserId(userId);
        return Result.success(coupons);
    }
    
    /**
     * 获取用户有效的红包列表
     * @param userId 用户ID
     * @return 有效红包列表
     */
    @GetMapping("/user/{userId}/valid")
    public Result<List<Coupon>> getValidCoupons(@PathVariable Long userId) {
        List<Coupon> coupons = couponService.getValidCoupons(userId);
        return Result.success(coupons);
    }
    
    /**
     * 分页查询红包列表
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @param userId 用户ID（可选）
     * @param status 状态（可选）
     * @return 红包列表
     */
    @GetMapping("/list")
    public Result<?> getCouponList(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) Long userId,
            @RequestParam(required = false) String status) {
        
        Map<String, Object> data = couponService.getCouponList(pageNum, pageSize, userId, status);
        return Result.success(data);
    }
    
    /**
     * 使用红包
     * @param id 红包ID
     * @return 使用结果
     */
    @PostMapping("/{id}/use")
    public Result<?> useCoupon(@PathVariable Long id) {
        try {
            Coupon coupon = couponService.useCoupon(id);
            return Result.success(coupon);
        } catch (Exception e) {
            return Result.fail("使用红包失败：" + e.getMessage());
        }
    }
    
    /**
     * 取消红包
     * @param id 红包ID
     * @return 取消结果
     */
    @PostMapping("/{id}/cancel")
    public Result<String> cancelCoupon(@PathVariable Long id) {
        boolean cancelled = couponService.cancelCoupon(id);
        
        if (cancelled) {
            return Result.success("红包已取消");
        } else {
            return Result.fail("取消红包失败，红包不存在或状态不允许取消");
        }
    }
    
    /**
     * 检查并更新过期红包
     * 系统管理接口，通常由定时任务调用
     * @return 更新结果
     */
    @PostMapping("/check-expired")
    public Result<String> checkAndUpdateExpiredCoupons() {
        int count = couponService.checkAndUpdateExpiredCoupons();
        return Result.success("已更新" + count + "个过期红包");
    }

    /**
     * 更新红包信息
     * @param coupon 红包信息
     * @return 更新结果
     */
    @PostMapping("/update")
    public Result<?> updateCoupon(@RequestBody Coupon coupon) {
        try {
            if (coupon.getId() == null) {
                return Result.fail("更新红包失败：缺少红包ID");
            }
            
            logger.info("更新红包ID={}, 有效期: 从 {} 到 {}", coupon.getId(), coupon.getValidFrom(), coupon.getValidTo());
            
            // 检查红包是否存在
            Coupon existingCoupon = couponService.getCouponById(coupon.getId());
            if (existingCoupon == null) {
                return Result.fail("更新红包失败：红包不存在");
            }
            
            // 检查红包状态是否为未使用，只允许更新未使用的红包
            if (!"未使用".equals(existingCoupon.getStatus())) {
                return Result.fail("更新红包失败：只能更新未使用的红包");
            }
            
            // 保留原始状态和创建时间
            coupon.setStatus(existingCoupon.getStatus());
            coupon.setCreateTime(existingCoupon.getCreateTime());
            
            // 处理结束时间，确保结束时间为当天的23:59:59
            if (coupon.getValidTo() != null) {
                LocalDateTime validTo = coupon.getValidTo();
                LocalDateTime adjustedValidTo = LocalDateTime.of(
                    validTo.toLocalDate(), 
                    LocalTime.of(23, 59, 59)
                );
                coupon.setValidTo(adjustedValidTo);
                logger.info("调整后的结束时间: {}", adjustedValidTo);
            }
            
            Coupon updated = couponService.createCoupon(coupon); // 复用创建方法进行更新
            return Result.success(updated);
        } catch (Exception e) {
            logger.error("更新红包失败", e);
            return Result.fail("更新红包失败：" + e.getMessage());
        }
    }
} 